#include <iostream>
#include <stdio.h>
#include <string>
#include <cstring>

class Construct {
public:
    Construct() = default;  // 无参构造函数1：不能初始化任何成员变量
    Construct(int age_, int high_, char* addr_); // 有参构造函数：初始化成员变量
    Construct(int age_, int high_, char* addr_, std::string name_){}; // 有参构造函数：初始化成员变量

    // 拷贝构造函数，使用一个对象初始化另外一个对象。如果类的成员变量都是基本类型，使用编译器默认的足够了
    // 如果类涉及指针等类型，则必须自己定义一个拷贝构造函数
    Construct(const Construct& con) = default;

    ~Construct();

public:
    void show();

private:
    int age;
    int high;
    char* addr;
    std::string name;
};

class Base {
public:
    Base();
    ~Base();
protected:
    void change_age();  // 子类继承可直接访问
public:
    // 外部（类对象）只能看到该函数，至于set_name/set_addr函数均是类内部函数，外部无法访问
    void show_val(int age, int high, char* addr, std::string name);
private:
    void set_age(int age);
    void set_addr(char* addr);
private:
    int m_age;
    int m_high;
    char* m_addr;
    std::string m_name;
};

class Flag {
public:
    Flag() = default;
    ~Flag() = default;
public:
    void show();
private:
    int age;
};

class Override {
public:
    Override() = default;
    ~Override() = default;
    Override(int val)
    {
        m_val = val;
    }
public:
    void show_val(int);
    void show_val(char);
    void show_output();

public:
    void operator+(const Override& rhs)
    {
        this->m_val += rhs.m_val; 
    }

private:
    int m_val;
};